package com.itany.corejava.code15_stream;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;

/**
 * @author MissChen
 * @version 1.0
 * @date 2023 年12月15日 11:36
 */
public class Test01_创建stream对象 {
    public static void main(String[] args) {
        //方式一:Collection体系的集合
        List<Integer> list = Arrays.asList(1, 3, 6, 7, 8, 10, 13, 15);
        Stream<Integer> stream = list.stream();
        System.out.println(stream);


        // forEach(Consumer<泛型> c)，方法参数是一个函数式接口
        // 用于遍历stream中的元素
        // stream.forEach(new Consumer<Integer>() {
        //     @Override
        //     public void accept(Integer integer) {
        //         System.out.println(integer);
        //     }
        // });

        // stream.forEach(integer -> System.out.println(integer));
        stream.forEach(System.out::println);

        // 方式二:Map体系的集合
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "aa");
        map.put(2, "bb");
        map.put(3, "cc");
        Stream<Integer> keyStream = map.keySet().stream();
        keyStream.forEach(System.out::println);

        Stream<Map.Entry<Integer, String>> entryStream = map.entrySet().stream();
        // entryStream.forEach(new Consumer<Map.Entry<Integer, String>>() {
        //     @Override
        //     public void accept(Map.Entry<Integer, String> integerStringEntry) {
        //         System.out.println(integerStringEntry);
        //     }
        // });

        // entryStream.forEach(integerStringEntry->System.out.println(integerStringEntry));
        entryStream.forEach(System.out::println);

        // 方式三:数组类型
        Integer[] arr={1,2,3,45,67};
        Stream<Integer> s1=Arrays.stream(arr);
        s1.forEach(System.out::println);


        // 通过Stream提供的静态方法进行获取
        String[] arr2={"上海","北京","重庆","南京","无锡"};
        Stream<String> ss=Stream.of(arr2);
        ss.forEach(System.out::println);

        // 方式四:可变长类型
        Stream<String> ss2=Stream.of("李白","杜甫","苏轼","项羽","虞姬","雷雨净");
        ss2.forEach(System.out::println);


        //方法五:无限流,将无限个元素添加到Stream流中，永远不停止

        // 通过Stream提供的静态方法iterate(T seed,UnaryOperator<T> f) 生成无限流
        // UnaryOperator<Integer> u1=UnaryOperator.identity();
        // Stream.iterate(T seed,UnaryOperator<T> f)
        //第一个参数：初始元素
        // 第二个参数：使用UnaryOperator对象，表示是每次都是同一个值
        // Stream<Integer> stream11=Stream.iterate(1,u1);
        // stream11.forEach(System.out::println);

        UnaryOperator<Integer> u2=new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer+1;
            }
        };
        Stream<Integer> stream12=Stream.iterate(1,integer -> integer+1);
        stream12.forEach(System.out::println);



    }
}
